package com.learn.algorlthm;

import java.util.ArrayList;
import java.util.PriorityQueue;

/**
 * @classname:
 * @Description:最小的k个数
 * @author: yfpu(fengpu.yang @ ucarinc.com)
 * @Date: 2018-08-06 13:55
 * 题目描述：
 * 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
 */
public class Learn40 {

    /**
     * 快速选择
     * 复杂度：O(N) + O(1)
     * 只有当允许修改数组元素时才可以使用
     * <p>
     * 快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，
     * 此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
     */

    public static ArrayList<Integer> getLeastNumbers_solution(int[] nums, int k) {
        ArrayList<Integer> ret = new ArrayList<>();
        if (k > nums.length || k <= 0)
            return ret;
        findKthSmallest(nums, k - 1);
        /* findKthSmallest会改变数组，使得前k个数都是最小的k个数 */

        for (int i = 0; i < k; i++)
            ret.add(nums[i]);

        return ret;
    }

    private static void findKthSmallest(int[] nums, int k) {
        int l = 0, h = nums.length - 1;
        while (l < h) {
            int j = partition(nums, l, h);
            if (j == k)
                break;

            if (j > k)
                h = j - 1;
            else
                l = j + 1;
        }
    }

    private static int partition(int[] nums, int l, int h) {
        int p = nums[l]; /* 切分元素 */
        int i = l, j = h + 1;
        while (true) {
            while (i != h && nums[++i] < p);
            while (j !=l && nums[--j] > p);

            if (i >= j)
                break;
            swap(nums, i, j);
        }
        swap(nums, l, j);

        return j;
    }


    private static void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }


    /**
     * 大小为k的最小堆
     *  复杂度：O(NlogK) + O(K)
     *  特别适合处理海量数据
     *
     * 应该使用大顶堆来维护最小堆，而不能直接创建一个小顶堆并设置一个大小，企图让小顶堆中的元素都是最小元素。
     * 维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，
     */

    public static ArrayList<Integer> getLeastNumbers_solution_2(int[] nums, int k) {
        if (k > nums.length || k <= 0)
            return new ArrayList<Integer>();
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
        for (int num : nums) {
            maxHeap.add(num);
            if (maxHeap.size() > k)
                maxHeap.poll();
        }
        return new ArrayList<>(maxHeap);
    }
}
